home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan).7z / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / internet / xip / iijppp.lzh / src / async.c next >
C/C++ Source or Header  |  1994-09-25  |  4KB  |  185 lines
  1. /*
  2.  *                 PPP Async HDLC Module
  3.  *
  4.  *        Written by Toshiharu OHNO (tony-o@iij.ad.jp)
  5.  *
  6.  *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
  7.  *
  8.  * Redistribution and use in source and binary forms are permitted
  9.  * provided that the above copyright notice and this paragraph are
  10.  * duplicated in all such forms and that any documentation,
  11.  * advertising materials, and other materials related to such
  12.  * distribution and use acknowledge that the software was developed
  13.  * by the Internet Initiative Japan, Inc.  The name of the
  14.  * IIJ may not be used to endorse or promote products derived
  15.  * from this software without specific prior written permission.
  16.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19.  *
  20.  *
  21.  */
  22. #include "fsm.h"
  23. #include "hdlc.h"
  24. #include "lcp.h"
  25. #include "lcpproto.h"
  26. #include "modem.h"
  27.  
  28. #define HDLCSIZE    (MAX_MRU*2+6)
  29.  
  30. struct async_state {
  31.   int mode;
  32.   int length;
  33.   struct mbuf *hpacket;
  34.   u_char hbuff[HDLCSIZE];    /* recv buffer */
  35.   u_char xbuff[HDLCSIZE];    /* xmit buffer */
  36.   u_long my_accmap;
  37.   u_long his_accmap;
  38. } AsyncState;
  39.  
  40. #define MODE_HUNT 0x01
  41. #define MODE_ESC  0x02
  42.  
  43. void
  44. AsyncInit()
  45. {
  46.   struct async_state *stp = &AsyncState;
  47.  
  48.   stp->mode = MODE_HUNT;
  49.   stp->my_accmap = stp->his_accmap = 0xffffffff;
  50. }
  51.  
  52. void
  53. SetLinkParams(lcp)
  54. struct lcpstate *lcp;
  55. {
  56.   struct async_state *stp = &AsyncState;
  57.  
  58.   stp->my_accmap = lcp->want_accmap;
  59.   stp->his_accmap = lcp->his_accmap;
  60. }
  61.  
  62. /*
  63.  * Encode into async HDLC byte code if necessary
  64.  */
  65. static void
  66. HdlcPutByte(cp, c, proto)
  67. u_char **cp;
  68. u_char c;
  69. int proto;
  70. {
  71.   u_char *wp;
  72.  
  73.   wp = *cp;
  74.   if ((c < 0x20 && (proto == PROTO_LCP || (AsyncState.his_accmap & (1<<c))))
  75.     || (c == HDLC_ESC) || (c == HDLC_SYN)) {
  76.     *wp++ = HDLC_ESC;
  77.     c ^= HDLC_XOR;
  78.   }
  79.   if (EscMap[32] && EscMap[c >> 3] & (c&7)) {
  80.     *wp++ = HDLC_ESC;
  81.     c ^= HDLC_XOR;
  82.   }
  83.   *wp++ = c;
  84.   *cp = wp;
  85. }
  86.  
  87. void
  88. AsyncOutput(pri, bp, proto)
  89. int pri;
  90. struct mbuf *bp;
  91. int proto;
  92. {
  93.   struct async_state *hs = &AsyncState;
  94.   u_char *cp, *sp, *ep;
  95.   struct mbuf *wp;
  96.   int cnt;
  97.  
  98.   if (plength(bp) > HDLCSIZE) {
  99.     pfree(bp);
  100.     return;
  101.   }
  102.   cp = hs->xbuff;
  103.   ep = cp + HDLCSIZE - 10;
  104.   wp = bp;
  105.   *cp ++ = HDLC_SYN;
  106.   while (wp) {
  107.     sp = MBUF_CTOP(wp);
  108.     for (cnt = wp->cnt; cnt > 0; cnt--) {
  109.       HdlcPutByte(&cp, *sp++, proto);
  110.       if (cp >= ep) {
  111.     pfree(bp);
  112.     return;
  113.       }
  114.     }
  115.     wp = wp->next;
  116.   }
  117.   *cp ++ = HDLC_SYN;
  118.  
  119.   cnt = cp - hs->xbuff;
  120.   LogDumpBuff(LOG_ASYNC, "WriteModem", hs->xbuff, cnt);
  121.   WriteModem(pri, (char *)hs->xbuff, cnt);
  122.   OsAddOutOctets(cnt);
  123.   pfree(bp);
  124. }
  125.  
  126. struct mbuf *
  127. AsyncDecode(c)
  128. u_char c;
  129. {
  130.   struct async_state *hs = &AsyncState;
  131.   struct mbuf *bp;
  132.  
  133.   if ((hs->mode & MODE_HUNT) && c != HDLC_SYN)
  134.     return(NULLBUFF);
  135.  
  136.   switch (c) {
  137.   case HDLC_SYN:
  138.     hs->mode &= ~MODE_HUNT;
  139.     if (hs->length) {    /* packet is ready. */
  140.       bp = mballoc(hs->length, MB_ASYNC);
  141.       mbwrite(bp, hs->hbuff, hs->length);
  142.       hs->length = 0;
  143.       return(bp);
  144.     }
  145.     break;
  146.   case HDLC_ESC:
  147.     if (!(hs->mode & MODE_ESC)) {
  148.       hs->mode |= MODE_ESC;
  149.       break;
  150.     }
  151.     /* Fall into ... */
  152.   default:
  153.     if (hs->length >= HDLCSIZE) {
  154.       /* packet is too large, discard it */
  155.       logprintf("too large, diacarding.\n");
  156.       hs->length = 0;
  157.       hs->mode = MODE_HUNT;
  158.       break;
  159.     }
  160.     if (hs->mode & MODE_ESC) {
  161.       c ^= HDLC_XOR;
  162.       hs->mode &= ~MODE_ESC;
  163.     }
  164.     hs->hbuff[hs->length++] = c;
  165.     break;
  166.   }
  167.   return NULLBUFF;
  168. }
  169.  
  170. void
  171. AsyncInput(buff, cnt)
  172. u_char *buff;
  173. int cnt;
  174. {
  175.   struct mbuf *bp;
  176.  
  177.   OsAddInOctets(cnt);
  178.   while (cnt > 0) {
  179.     bp = AsyncDecode(*buff++);
  180.     if (bp)
  181.       HdlcInput(bp);
  182.     cnt--;
  183.   }
  184. }
  185.